home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / exec_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  60KB  |  2,209 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_EXEC_H
  4. #define _PPCPRAGMA_EXEC_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__EXEC_H
  7. #include <powerup/ppcinline/exec.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef EXEC_BASE_NAME
  24. #define EXEC_BASE_NAME SysBase
  25. #endif /* !EXEC_BASE_NAME */
  26.  
  27. #define    AbortIO(ioRequest)    _AbortIO(EXEC_BASE_NAME, ioRequest)
  28.  
  29. static __inline void
  30. _AbortIO(void *SysBase, struct IORequest *ioRequest)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a1        =(ULONG) ioRequest;
  40.     MyCaos.caos_Un.Offset    =    (-480);
  41.     MyCaos.a6        =(ULONG) SysBase;    
  42.     PPCCallOS(&MyCaos);
  43. }
  44.  
  45. #define    AddDevice(device)    _AddDevice(EXEC_BASE_NAME, device)
  46.  
  47. static __inline void
  48. _AddDevice(void *SysBase, struct Device *device)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.a1        =(ULONG) device;
  58.     MyCaos.caos_Un.Offset    =    (-432);
  59.     MyCaos.a6        =(ULONG) SysBase;    
  60.     PPCCallOS(&MyCaos);
  61. }
  62.  
  63. #define    AddHead(list, node)    _AddHead(EXEC_BASE_NAME, list, node)
  64.  
  65. static __inline void
  66. _AddHead(void *SysBase, struct List *list, struct Node *node)
  67. {
  68. struct Caos    MyCaos;
  69.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  70. //    MyCaos.M68kStart    =    NULL;
  71. //    MyCaos.M68kSize        =    0;
  72.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.PPCStart        =    NULL;
  74. //    MyCaos.PPCSize        =    0;
  75.     MyCaos.a0        =(ULONG) list;
  76.     MyCaos.a1        =(ULONG) node;
  77.     MyCaos.caos_Un.Offset    =    (-240);
  78.     MyCaos.a6        =(ULONG) SysBase;    
  79.     PPCCallOS(&MyCaos);
  80. }
  81.  
  82. #define    AddIntServer(intNumber, interrupt)    _AddIntServer(EXEC_BASE_NAME, intNumber, interrupt)
  83.  
  84. static __inline void
  85. _AddIntServer(void *SysBase, long intNumber, struct Interrupt *interrupt)
  86. {
  87. struct Caos    MyCaos;
  88.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  89. //    MyCaos.M68kStart    =    NULL;
  90. //    MyCaos.M68kSize        =    0;
  91.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  92. //    MyCaos.PPCStart        =    NULL;
  93. //    MyCaos.PPCSize        =    0;
  94.     MyCaos.d0        =(ULONG) intNumber;
  95.     MyCaos.a1        =(ULONG) interrupt;
  96.     MyCaos.caos_Un.Offset    =    (-168);
  97.     MyCaos.a6        =(ULONG) SysBase;    
  98.     PPCCallOS(&MyCaos);
  99. }
  100.  
  101. #define    AddLibrary(library)    _AddLibrary(EXEC_BASE_NAME, library)
  102.  
  103. static __inline void
  104. _AddLibrary(void *SysBase, struct Library *library)
  105. {
  106. struct Caos    MyCaos;
  107.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.M68kStart    =    NULL;
  109. //    MyCaos.M68kSize        =    0;
  110.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.PPCStart        =    NULL;
  112. //    MyCaos.PPCSize        =    0;
  113.     MyCaos.a1        =(ULONG) library;
  114.     MyCaos.caos_Un.Offset    =    (-396);
  115.     MyCaos.a6        =(ULONG) SysBase;    
  116.     PPCCallOS(&MyCaos);
  117. }
  118.  
  119. #define    AddMemHandler(memhand)    _AddMemHandler(EXEC_BASE_NAME, memhand)
  120.  
  121. static __inline void
  122. _AddMemHandler(void *SysBase, struct Interrupt *memhand)
  123. {
  124. struct Caos    MyCaos;
  125.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  126. //    MyCaos.M68kStart    =    NULL;
  127. //    MyCaos.M68kSize        =    0;
  128.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  129. //    MyCaos.PPCStart        =    NULL;
  130. //    MyCaos.PPCSize        =    0;
  131.     MyCaos.a1        =(ULONG) memhand;
  132.     MyCaos.caos_Un.Offset    =    (-774);
  133.     MyCaos.a6        =(ULONG) SysBase;    
  134.     PPCCallOS(&MyCaos);
  135. }
  136.  
  137. #define    AddMemList(size, attributes, pri, base, name)    _AddMemList(EXEC_BASE_NAME, size, attributes, pri, base, name)
  138.  
  139. static __inline void
  140. _AddMemList(void *SysBase, unsigned long size, unsigned long attributes, long pri, APTR base, UBYTE *name)
  141. {
  142. struct Caos    MyCaos;
  143.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  144. //    MyCaos.M68kStart    =    NULL;
  145. //    MyCaos.M68kSize        =    0;
  146.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  147. //    MyCaos.PPCStart        =    NULL;
  148. //    MyCaos.PPCSize        =    0;
  149.     MyCaos.d0        =(ULONG) size;
  150.     MyCaos.d1        =(ULONG) attributes;
  151.     MyCaos.d2        =(ULONG) pri;
  152.     MyCaos.a0        =(ULONG) base;
  153.     MyCaos.a1        =(ULONG) name;
  154.     MyCaos.caos_Un.Offset    =    (-618);
  155.     MyCaos.a6        =(ULONG) SysBase;    
  156.     PPCCallOS(&MyCaos);
  157. }
  158.  
  159. #define    AddPort(port)    _AddPort(EXEC_BASE_NAME, port)
  160.  
  161. static __inline void
  162. _AddPort(void *SysBase, struct MsgPort *port)
  163. {
  164. struct Caos    MyCaos;
  165.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  166. //    MyCaos.M68kStart    =    NULL;
  167. //    MyCaos.M68kSize        =    0;
  168.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.PPCStart        =    NULL;
  170. //    MyCaos.PPCSize        =    0;
  171.     MyCaos.a1        =(ULONG) port;
  172.     MyCaos.caos_Un.Offset    =    (-354);
  173.     MyCaos.a6        =(ULONG) SysBase;    
  174.     PPCCallOS(&MyCaos);
  175. }
  176.  
  177. #define    AddResource(resource)    _AddResource(EXEC_BASE_NAME, resource)
  178.  
  179. static __inline void
  180. _AddResource(void *SysBase, APTR resource)
  181. {
  182. struct Caos    MyCaos;
  183.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  184. //    MyCaos.M68kStart    =    NULL;
  185. //    MyCaos.M68kSize        =    0;
  186.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  187. //    MyCaos.PPCStart        =    NULL;
  188. //    MyCaos.PPCSize        =    0;
  189.     MyCaos.a1        =(ULONG) resource;
  190.     MyCaos.caos_Un.Offset    =    (-486);
  191.     MyCaos.a6        =(ULONG) SysBase;    
  192.     PPCCallOS(&MyCaos);
  193. }
  194.  
  195. #define    AddSemaphore(sigSem)    _AddSemaphore(EXEC_BASE_NAME, sigSem)
  196.  
  197. static __inline void
  198. _AddSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  199. {
  200. struct Caos    MyCaos;
  201.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  202. //    MyCaos.M68kStart    =    NULL;
  203. //    MyCaos.M68kSize        =    0;
  204.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  205. //    MyCaos.PPCStart        =    NULL;
  206. //    MyCaos.PPCSize        =    0;
  207.     MyCaos.a1        =(ULONG) sigSem;
  208.     MyCaos.caos_Un.Offset    =    (-600);
  209.     MyCaos.a6        =(ULONG) SysBase;    
  210.     PPCCallOS(&MyCaos);
  211. }
  212.  
  213. #define    AddTail(list, node)    _AddTail(EXEC_BASE_NAME, list, node)
  214.  
  215. static __inline void
  216. _AddTail(void *SysBase, struct List *list, struct Node *node)
  217. {
  218. struct Caos    MyCaos;
  219.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  220. //    MyCaos.M68kStart    =    NULL;
  221. //    MyCaos.M68kSize        =    0;
  222.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  223. //    MyCaos.PPCStart        =    NULL;
  224. //    MyCaos.PPCSize        =    0;
  225.     MyCaos.a0        =(ULONG) list;
  226.     MyCaos.a1        =(ULONG) node;
  227.     MyCaos.caos_Un.Offset    =    (-246);
  228.     MyCaos.a6        =(ULONG) SysBase;    
  229.     PPCCallOS(&MyCaos);
  230. }
  231.  
  232. #define    AddTask(task, initPC, finalPC)    _AddTask(EXEC_BASE_NAME, task, initPC, finalPC)
  233.  
  234. static __inline APTR
  235. _AddTask(void *SysBase, struct Task *task, APTR initPC, APTR finalPC)
  236. {
  237. struct Caos    MyCaos;
  238.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  239. //    MyCaos.M68kStart    =    NULL;
  240. //    MyCaos.M68kSize        =    0;
  241.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  242. //    MyCaos.PPCStart        =    NULL;
  243. //    MyCaos.PPCSize        =    0;
  244.     MyCaos.a1        =(ULONG) task;
  245.     MyCaos.a2        =(ULONG) initPC;
  246.     MyCaos.a3        =(ULONG) finalPC;
  247.     MyCaos.caos_Un.Offset    =    (-282);
  248.     MyCaos.a6        =(ULONG) SysBase;    
  249.     return((APTR)PPCCallOS(&MyCaos));
  250. }
  251.  
  252. #define    Alert(alertNum)    _Alert(EXEC_BASE_NAME, alertNum)
  253.  
  254. static __inline void
  255. _Alert(void *SysBase, unsigned long alertNum)
  256. {
  257. struct Caos    MyCaos;
  258.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  259. //    MyCaos.M68kStart    =    NULL;
  260. //    MyCaos.M68kSize        =    0;
  261.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  262. //    MyCaos.PPCStart        =    NULL;
  263. //    MyCaos.PPCSize        =    0;
  264.     MyCaos.d7        =(ULONG) alertNum;
  265.     MyCaos.caos_Un.Offset    =    (-108);
  266.     MyCaos.a6        =(ULONG) SysBase;    
  267.     PPCCallOS(&MyCaos);
  268. }
  269.  
  270. #define    AllocAbs(byteSize, location)    _AllocAbs(EXEC_BASE_NAME, byteSize, location)
  271.  
  272. static __inline APTR
  273. _AllocAbs(void *SysBase, unsigned long byteSize, APTR location)
  274. {
  275. struct Caos    MyCaos;
  276.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  277. //    MyCaos.M68kStart    =    NULL;
  278. //    MyCaos.M68kSize        =    0;
  279.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  280. //    MyCaos.PPCStart        =    NULL;
  281. //    MyCaos.PPCSize        =    0;
  282.     MyCaos.d0        =(ULONG) byteSize;
  283.     MyCaos.a1        =(ULONG) location;
  284.     MyCaos.caos_Un.Offset    =    (-204);
  285.     MyCaos.a6        =(ULONG) SysBase;    
  286.     return((APTR)PPCCallOS(&MyCaos));
  287. }
  288.  
  289. #define    AllocEntry(entry)    _AllocEntry(EXEC_BASE_NAME, entry)
  290.  
  291. static __inline struct MemList *
  292. _AllocEntry(void *SysBase, struct MemList *entry)
  293. {
  294. struct Caos    MyCaos;
  295.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  296. //    MyCaos.M68kStart    =    NULL;
  297. //    MyCaos.M68kSize        =    0;
  298.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  299. //    MyCaos.PPCStart        =    NULL;
  300. //    MyCaos.PPCSize        =    0;
  301.     MyCaos.a0        =(ULONG) entry;
  302.     MyCaos.caos_Un.Offset    =    (-222);
  303.     MyCaos.a6        =(ULONG) SysBase;    
  304.     return((struct MemList *)PPCCallOS(&MyCaos));
  305. }
  306.  
  307. #define    AllocMem(byteSize, requirements)    _AllocMem(EXEC_BASE_NAME, byteSize, requirements)
  308.  
  309. static __inline APTR
  310. _AllocMem(void *SysBase, unsigned long byteSize, unsigned long requirements)
  311. {
  312. struct Caos    MyCaos;
  313.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  314. //    MyCaos.M68kStart    =    NULL;
  315. //    MyCaos.M68kSize        =    0;
  316.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  317. //    MyCaos.PPCStart        =    NULL;
  318. //    MyCaos.PPCSize        =    0;
  319.     MyCaos.d0        =(ULONG) byteSize;
  320.     MyCaos.d1        =(ULONG) requirements;
  321.     MyCaos.caos_Un.Offset    =    (-198);
  322.     MyCaos.a6        =(ULONG) SysBase;    
  323.     return((APTR)PPCCallOS(&MyCaos));
  324. }
  325.  
  326. #define    AllocPooled(poolHeader, memSize)    _AllocPooled(EXEC_BASE_NAME, poolHeader, memSize)
  327.  
  328. static __inline APTR
  329. _AllocPooled(void *SysBase, APTR poolHeader, unsigned long memSize)
  330. {
  331. struct Caos    MyCaos;
  332.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.M68kStart    =    NULL;
  334. //    MyCaos.M68kSize        =    0;
  335.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  336. //    MyCaos.PPCStart        =    NULL;
  337. //    MyCaos.PPCSize        =    0;
  338.     MyCaos.a0        =(ULONG) poolHeader;
  339.     MyCaos.d0        =(ULONG) memSize;
  340.     MyCaos.caos_Un.Offset    =    (-708);
  341.     MyCaos.a6        =(ULONG) SysBase;    
  342.     return((APTR)PPCCallOS(&MyCaos));
  343. }
  344.  
  345. #define    AllocSignal(signalNum)    _AllocSignal(EXEC_BASE_NAME, signalNum)
  346.  
  347. static __inline BYTE
  348. _AllocSignal(void *SysBase, long signalNum)
  349. {
  350. struct Caos    MyCaos;
  351.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  352. //    MyCaos.M68kStart    =    NULL;
  353. //    MyCaos.M68kSize        =    0;
  354.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  355. //    MyCaos.PPCStart        =    NULL;
  356. //    MyCaos.PPCSize        =    0;
  357.     MyCaos.d0        =(ULONG) signalNum;
  358.     MyCaos.caos_Un.Offset    =    (-330);
  359.     MyCaos.a6        =(ULONG) SysBase;    
  360.     return((BYTE)PPCCallOS(&MyCaos));
  361. }
  362.  
  363. #define    AllocTrap(trapNum)    _AllocTrap(EXEC_BASE_NAME, trapNum)
  364.  
  365. static __inline LONG
  366. _AllocTrap(void *SysBase, long trapNum)
  367. {
  368. struct Caos    MyCaos;
  369.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  370. //    MyCaos.M68kStart    =    NULL;
  371. //    MyCaos.M68kSize        =    0;
  372.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  373. //    MyCaos.PPCStart        =    NULL;
  374. //    MyCaos.PPCSize        =    0;
  375.     MyCaos.d0        =(ULONG) trapNum;
  376.     MyCaos.caos_Un.Offset    =    (-342);
  377.     MyCaos.a6        =(ULONG) SysBase;    
  378.     return((LONG)PPCCallOS(&MyCaos));
  379. }
  380.  
  381. #define    AllocVec(byteSize, requirements)    _AllocVec(EXEC_BASE_NAME, byteSize, requirements)
  382.  
  383. static __inline APTR
  384. _AllocVec(void *SysBase, unsigned long byteSize, unsigned long requirements)
  385. {
  386. struct Caos    MyCaos;
  387.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  388. //    MyCaos.M68kStart    =    NULL;
  389. //    MyCaos.M68kSize        =    0;
  390.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  391. //    MyCaos.PPCStart        =    NULL;
  392. //    MyCaos.PPCSize        =    0;
  393.     MyCaos.d0        =(ULONG) byteSize;
  394.     MyCaos.d1        =(ULONG) requirements;
  395.     MyCaos.caos_Un.Offset    =    (-684);
  396.     MyCaos.a6        =(ULONG) SysBase;    
  397.     return((APTR)PPCCallOS(&MyCaos));
  398. }
  399.  
  400. #define    Allocate(freeList, byteSize)    _Allocate(EXEC_BASE_NAME, freeList, byteSize)
  401.  
  402. static __inline APTR
  403. _Allocate(void *SysBase, struct MemHeader *freeList, unsigned long byteSize)
  404. {
  405. struct Caos    MyCaos;
  406.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  407. //    MyCaos.M68kStart    =    NULL;
  408. //    MyCaos.M68kSize        =    0;
  409.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  410. //    MyCaos.PPCStart        =    NULL;
  411. //    MyCaos.PPCSize        =    0;
  412.     MyCaos.a0        =(ULONG) freeList;
  413.     MyCaos.d0        =(ULONG) byteSize;
  414.     MyCaos.caos_Un.Offset    =    (-186);
  415.     MyCaos.a6        =(ULONG) SysBase;    
  416.     return((APTR)PPCCallOS(&MyCaos));
  417. }
  418.  
  419. #define    AttemptSemaphore(sigSem)    _AttemptSemaphore(EXEC_BASE_NAME, sigSem)
  420.  
  421. static __inline ULONG
  422. _AttemptSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  423. {
  424. struct Caos    MyCaos;
  425.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  426. //    MyCaos.M68kStart    =    NULL;
  427. //    MyCaos.M68kSize        =    0;
  428.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  429. //    MyCaos.PPCStart        =    NULL;
  430. //    MyCaos.PPCSize        =    0;
  431.     MyCaos.a0        =(ULONG) sigSem;
  432.     MyCaos.caos_Un.Offset    =    (-576);
  433.     MyCaos.a6        =(ULONG) SysBase;    
  434.     return((ULONG)PPCCallOS(&MyCaos));
  435. }
  436.  
  437. #define    AttemptSemaphoreShared(sigSem)    _AttemptSemaphoreShared(EXEC_BASE_NAME, sigSem)
  438.  
  439. static __inline ULONG
  440. _AttemptSemaphoreShared(void *SysBase, struct SignalSemaphore *sigSem)
  441. {
  442. struct Caos    MyCaos;
  443.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  444. //    MyCaos.M68kStart    =    NULL;
  445. //    MyCaos.M68kSize        =    0;
  446.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  447. //    MyCaos.PPCStart        =    NULL;
  448. //    MyCaos.PPCSize        =    0;
  449.     MyCaos.a0        =(ULONG) sigSem;
  450.     MyCaos.caos_Un.Offset    =    (-720);
  451.     MyCaos.a6        =(ULONG) SysBase;    
  452.     return((ULONG)PPCCallOS(&MyCaos));
  453. }
  454.  
  455. #define    AvailMem(requirements)    _AvailMem(EXEC_BASE_NAME, requirements)
  456.  
  457. static __inline ULONG
  458. _AvailMem(void *SysBase, unsigned long requirements)
  459. {
  460. struct Caos    MyCaos;
  461.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  462. //    MyCaos.M68kStart    =    NULL;
  463. //    MyCaos.M68kSize        =    0;
  464.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  465. //    MyCaos.PPCStart        =    NULL;
  466. //    MyCaos.PPCSize        =    0;
  467.     MyCaos.d1        =(ULONG) requirements;
  468.     MyCaos.caos_Un.Offset    =    (-216);
  469.     MyCaos.a6        =(ULONG) SysBase;    
  470.     return((ULONG)PPCCallOS(&MyCaos));
  471. }
  472.  
  473. #define    CacheClearE(address, length, caches)    _CacheClearE(EXEC_BASE_NAME, address, length, caches)
  474.  
  475. static __inline void
  476. _CacheClearE(void *SysBase, APTR address, unsigned long length, unsigned long caches)
  477. {
  478. struct Caos    MyCaos;
  479.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  480. //    MyCaos.M68kStart    =    NULL;
  481. //    MyCaos.M68kSize        =    0;
  482.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  483. //    MyCaos.PPCStart        =    NULL;
  484. //    MyCaos.PPCSize        =    0;
  485.     MyCaos.a0        =(ULONG) address;
  486.     MyCaos.d0        =(ULONG) length;
  487.     MyCaos.d1        =(ULONG) caches;
  488.     MyCaos.caos_Un.Offset    =    (-642);
  489.     MyCaos.a6        =(ULONG) SysBase;    
  490.     PPCCallOS(&MyCaos);
  491. }
  492.  
  493. #define    CacheClearU()    _CacheClearU(EXEC_BASE_NAME)
  494.  
  495. static __inline void
  496. _CacheClearU(void *SysBase)
  497. {
  498. struct Caos    MyCaos;
  499.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  500. //    MyCaos.M68kStart    =    NULL;
  501. //    MyCaos.M68kSize        =    0;
  502.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  503. //    MyCaos.PPCStart        =    NULL;
  504. //    MyCaos.PPCSize        =    0;
  505.     MyCaos.caos_Un.Offset    =    (-636);
  506.     MyCaos.a6        =(ULONG) SysBase;    
  507.     PPCCallOS(&MyCaos);
  508. }
  509.  
  510. #define    CacheControl(cacheBits, cacheMask)    _CacheControl(EXEC_BASE_NAME, cacheBits, cacheMask)
  511.  
  512. static __inline ULONG
  513. _CacheControl(void *SysBase, unsigned long cacheBits, unsigned long cacheMask)
  514. {
  515. struct Caos    MyCaos;
  516.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  517. //    MyCaos.M68kStart    =    NULL;
  518. //    MyCaos.M68kSize        =    0;
  519.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  520. //    MyCaos.PPCStart        =    NULL;
  521. //    MyCaos.PPCSize        =    0;
  522.     MyCaos.d0        =(ULONG) cacheBits;
  523.     MyCaos.d1        =(ULONG) cacheMask;
  524.     MyCaos.caos_Un.Offset    =    (-648);
  525.     MyCaos.a6        =(ULONG) SysBase;    
  526.     return((ULONG)PPCCallOS(&MyCaos));
  527. }
  528.  
  529. #define    CachePostDMA(address, length, flags)    _CachePostDMA(EXEC_BASE_NAME, address, length, flags)
  530.  
  531. static __inline void
  532. _CachePostDMA(void *SysBase, APTR address, ULONG *length, unsigned long flags)
  533. {
  534. struct Caos    MyCaos;
  535.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  536. //    MyCaos.M68kStart    =    NULL;
  537. //    MyCaos.M68kSize        =    0;
  538.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  539. //    MyCaos.PPCStart        =    NULL;
  540. //    MyCaos.PPCSize        =    0;
  541.     MyCaos.a0        =(ULONG) address;
  542.     MyCaos.a1        =(ULONG) length;
  543.     MyCaos.d0        =(ULONG) flags;
  544.     MyCaos.caos_Un.Offset    =    (-768);
  545.     MyCaos.a6        =(ULONG) SysBase;    
  546.     PPCCallOS(&MyCaos);
  547. }
  548.  
  549. #define    CachePreDMA(address, length, flags)    _CachePreDMA(EXEC_BASE_NAME, address, length, flags)
  550.  
  551. static __inline APTR
  552. _CachePreDMA(void *SysBase, APTR address, ULONG *length, unsigned long flags)
  553. {
  554. struct Caos    MyCaos;
  555.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  556. //    MyCaos.M68kStart    =    NULL;
  557. //    MyCaos.M68kSize        =    0;
  558.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  559. //    MyCaos.PPCStart        =    NULL;
  560. //    MyCaos.PPCSize        =    0;
  561.     MyCaos.a0        =(ULONG) address;
  562.     MyCaos.a1        =(ULONG) length;
  563.     MyCaos.d0        =(ULONG) flags;
  564.     MyCaos.caos_Un.Offset    =    (-762);
  565.     MyCaos.a6        =(ULONG) SysBase;    
  566.     return((APTR)PPCCallOS(&MyCaos));
  567. }
  568.  
  569. #define    Cause(interrupt)    _Cause(EXEC_BASE_NAME, interrupt)
  570.  
  571. static __inline void
  572. _Cause(void *SysBase, struct Interrupt *interrupt)
  573. {
  574. struct Caos    MyCaos;
  575.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  576. //    MyCaos.M68kStart    =    NULL;
  577. //    MyCaos.M68kSize        =    0;
  578.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  579. //    MyCaos.PPCStart        =    NULL;
  580. //    MyCaos.PPCSize        =    0;
  581.     MyCaos.a1        =(ULONG) interrupt;
  582.     MyCaos.caos_Un.Offset    =    (-180);
  583.     MyCaos.a6        =(ULONG) SysBase;    
  584.     PPCCallOS(&MyCaos);
  585. }
  586.  
  587. #define    CheckIO(ioRequest)    _CheckIO(EXEC_BASE_NAME, ioRequest)
  588.  
  589. static __inline struct IORequest *
  590. _CheckIO(void *SysBase, struct IORequest *ioRequest)
  591. {
  592. struct Caos    MyCaos;
  593.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  594. //    MyCaos.M68kStart    =    NULL;
  595. //    MyCaos.M68kSize        =    0;
  596.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  597. //    MyCaos.PPCStart        =    NULL;
  598. //    MyCaos.PPCSize        =    0;
  599.     MyCaos.a1        =(ULONG) ioRequest;
  600.     MyCaos.caos_Un.Offset    =    (-468);
  601.     MyCaos.a6        =(ULONG) SysBase;    
  602.     return((struct IORequest *)PPCCallOS(&MyCaos));
  603. }
  604.  
  605. #define    ChildFree(tid)    _ChildFree(EXEC_BASE_NAME, tid)
  606.  
  607. static __inline void
  608. _ChildFree(void *SysBase, APTR tid)
  609. {
  610. struct Caos    MyCaos;
  611.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  612. //    MyCaos.M68kStart    =    NULL;
  613. //    MyCaos.M68kSize        =    0;
  614.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  615. //    MyCaos.PPCStart        =    NULL;
  616. //    MyCaos.PPCSize        =    0;
  617.     MyCaos.d0        =(ULONG) tid;
  618.     MyCaos.caos_Un.Offset    =    (-738);
  619.     MyCaos.a6        =(ULONG) SysBase;    
  620.     PPCCallOS(&MyCaos);
  621. }
  622.  
  623. #define    ChildOrphan(tid)    _ChildOrphan(EXEC_BASE_NAME, tid)
  624.  
  625. static __inline void
  626. _ChildOrphan(void *SysBase, APTR tid)
  627. {
  628. struct Caos    MyCaos;
  629.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  630. //    MyCaos.M68kStart    =    NULL;
  631. //    MyCaos.M68kSize        =    0;
  632.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  633. //    MyCaos.PPCStart        =    NULL;
  634. //    MyCaos.PPCSize        =    0;
  635.     MyCaos.d0        =(ULONG) tid;
  636.     MyCaos.caos_Un.Offset    =    (-744);
  637.     MyCaos.a6        =(ULONG) SysBase;    
  638.     PPCCallOS(&MyCaos);
  639. }
  640.  
  641. #define    ChildStatus(tid)    _ChildStatus(EXEC_BASE_NAME, tid)
  642.  
  643. static __inline void
  644. _ChildStatus(void *SysBase, APTR tid)
  645. {
  646. struct Caos    MyCaos;
  647.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  648. //    MyCaos.M68kStart    =    NULL;
  649. //    MyCaos.M68kSize        =    0;
  650.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  651. //    MyCaos.PPCStart        =    NULL;
  652. //    MyCaos.PPCSize        =    0;
  653.     MyCaos.d0        =(ULONG) tid;
  654.     MyCaos.caos_Un.Offset    =    (-750);
  655.     MyCaos.a6        =(ULONG) SysBase;    
  656.     PPCCallOS(&MyCaos);
  657. }
  658.  
  659. #define    ChildWait(tid)    _ChildWait(EXEC_BASE_NAME, tid)
  660.  
  661. static __inline void
  662. _ChildWait(void *SysBase, APTR tid)
  663. {
  664. struct Caos    MyCaos;
  665.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  666. //    MyCaos.M68kStart    =    NULL;
  667. //    MyCaos.M68kSize        =    0;
  668.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  669. //    MyCaos.PPCStart        =    NULL;
  670. //    MyCaos.PPCSize        =    0;
  671.     MyCaos.d0        =(ULONG) tid;
  672.     MyCaos.caos_Un.Offset    =    (-756);
  673.     MyCaos.a6        =(ULONG) SysBase;    
  674.     PPCCallOS(&MyCaos);
  675. }
  676.  
  677. #define    CloseDevice(ioRequest)    _CloseDevice(EXEC_BASE_NAME, ioRequest)
  678.  
  679. static __inline void
  680. _CloseDevice(void *SysBase, struct IORequest *ioRequest)
  681. {
  682. struct Caos    MyCaos;
  683.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  684. //    MyCaos.M68kStart    =    NULL;
  685. //    MyCaos.M68kSize        =    0;
  686.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  687. //    MyCaos.PPCStart        =    NULL;
  688. //    MyCaos.PPCSize        =    0;
  689.     MyCaos.a1        =(ULONG) ioRequest;
  690.     MyCaos.caos_Un.Offset    =    (-450);
  691.     MyCaos.a6        =(ULONG) SysBase;    
  692.     PPCCallOS(&MyCaos);
  693. }
  694.  
  695. #define    CloseLibrary(library)    _CloseLibrary(EXEC_BASE_NAME, library)
  696.  
  697. static __inline void
  698. _CloseLibrary(void *SysBase, struct Library *library)
  699. {
  700. struct Caos    MyCaos;
  701.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  702. //    MyCaos.M68kStart    =    NULL;
  703. //    MyCaos.M68kSize        =    0;
  704.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  705. //    MyCaos.PPCStart        =    NULL;
  706. //    MyCaos.PPCSize        =    0;
  707.     MyCaos.a1        =(ULONG) library;
  708.     MyCaos.caos_Un.Offset    =    (-414);
  709.     MyCaos.a6        =(ULONG) SysBase;    
  710.     PPCCallOS(&MyCaos);
  711. }
  712.  
  713. #define    ColdReboot()    _ColdReboot(EXEC_BASE_NAME)
  714.  
  715. static __inline void
  716. _ColdReboot(void *SysBase)
  717. {
  718. struct Caos    MyCaos;
  719.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  720. //    MyCaos.M68kStart    =    NULL;
  721. //    MyCaos.M68kSize        =    0;
  722.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  723. //    MyCaos.PPCStart        =    NULL;
  724. //    MyCaos.PPCSize        =    0;
  725.     MyCaos.caos_Un.Offset    =    (-726);
  726.     MyCaos.a6        =(ULONG) SysBase;    
  727.     PPCCallOS(&MyCaos);
  728. }
  729.  
  730. #define    CopyMem(source, dest, size)    _CopyMem(EXEC_BASE_NAME, source, dest, size)
  731.  
  732. static __inline void
  733. _CopyMem(void *SysBase, APTR source, APTR dest, unsigned long size)
  734. {
  735. struct Caos    MyCaos;
  736.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  737. //    MyCaos.M68kStart    =    NULL;
  738. //    MyCaos.M68kSize        =    0;
  739.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  740. //    MyCaos.PPCStart        =    NULL;
  741. //    MyCaos.PPCSize        =    0;
  742.     MyCaos.a0        =(ULONG) source;
  743.     MyCaos.a1        =(ULONG) dest;
  744.     MyCaos.d0        =(ULONG) size;
  745.     MyCaos.caos_Un.Offset    =    (-624);
  746.     MyCaos.a6        =(ULONG) SysBase;    
  747.     PPCCallOS(&MyCaos);
  748. }
  749.  
  750. #define    CopyMemQuick(source, dest, size)    _CopyMemQuick(EXEC_BASE_NAME, source, dest, size)
  751.  
  752. static __inline void
  753. _CopyMemQuick(void *SysBase, APTR source, APTR dest, unsigned long size)
  754. {
  755. struct Caos    MyCaos;
  756.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  757. //    MyCaos.M68kStart    =    NULL;
  758. //    MyCaos.M68kSize        =    0;
  759.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  760. //    MyCaos.PPCStart        =    NULL;
  761. //    MyCaos.PPCSize        =    0;
  762.     MyCaos.a0        =(ULONG) source;
  763.     MyCaos.a1        =(ULONG) dest;
  764.     MyCaos.d0        =(ULONG) size;
  765.     MyCaos.caos_Un.Offset    =    (-630);
  766.     MyCaos.a6        =(ULONG) SysBase;    
  767.     PPCCallOS(&MyCaos);
  768. }
  769.  
  770. #define    CreateIORequest(port, size)    _CreateIORequest(EXEC_BASE_NAME, port, size)
  771.  
  772. static __inline APTR
  773. _CreateIORequest(void *SysBase, struct MsgPort *port, unsigned long size)
  774. {
  775. struct Caos    MyCaos;
  776.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  777. //    MyCaos.M68kStart    =    NULL;
  778. //    MyCaos.M68kSize        =    0;
  779.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  780. //    MyCaos.PPCStart        =    NULL;
  781. //    MyCaos.PPCSize        =    0;
  782.     MyCaos.a0        =(ULONG) port;
  783.     MyCaos.d0        =(ULONG) size;
  784.     MyCaos.caos_Un.Offset    =    (-654);
  785.     MyCaos.a6        =(ULONG) SysBase;    
  786.     return((APTR)PPCCallOS(&MyCaos));
  787. }
  788.  
  789. #define    CreateMsgPort()    _CreateMsgPort(EXEC_BASE_NAME)
  790.  
  791. static __inline struct MsgPort *
  792. _CreateMsgPort(void *SysBase)
  793. {
  794. struct Caos    MyCaos;
  795.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  796. //    MyCaos.M68kStart    =    NULL;
  797. //    MyCaos.M68kSize        =    0;
  798.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  799. //    MyCaos.PPCStart        =    NULL;
  800. //    MyCaos.PPCSize        =    0;
  801.     MyCaos.caos_Un.Offset    =    (-666);
  802.     MyCaos.a6        =(ULONG) SysBase;    
  803.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  804. }
  805.  
  806. #define    CreatePool(requirements, puddleSize, threshSize)    _CreatePool(EXEC_BASE_NAME, requirements, puddleSize, threshSize)
  807.  
  808. static __inline APTR
  809. _CreatePool(void *SysBase, unsigned long requirements, unsigned long puddleSize, unsigned long threshSize)
  810. {
  811. struct Caos    MyCaos;
  812.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  813. //    MyCaos.M68kStart    =    NULL;
  814. //    MyCaos.M68kSize        =    0;
  815.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  816. //    MyCaos.PPCStart        =    NULL;
  817. //    MyCaos.PPCSize        =    0;
  818.     MyCaos.d0        =(ULONG) requirements;
  819.     MyCaos.d1        =(ULONG) puddleSize;
  820.     MyCaos.d2        =(ULONG) threshSize;
  821.     MyCaos.caos_Un.Offset    =    (-696);
  822.     MyCaos.a6        =(ULONG) SysBase;    
  823.     return((APTR)PPCCallOS(&MyCaos));
  824. }
  825.  
  826. #define    Deallocate(freeList, memoryBlock, byteSize)    _Deallocate(EXEC_BASE_NAME, freeList, memoryBlock, byteSize)
  827.  
  828. static __inline void
  829. _Deallocate(void *SysBase, struct MemHeader *freeList, APTR memoryBlock, unsigned long byteSize)
  830. {
  831. struct Caos    MyCaos;
  832.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  833. //    MyCaos.M68kStart    =    NULL;
  834. //    MyCaos.M68kSize        =    0;
  835.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  836. //    MyCaos.PPCStart        =    NULL;
  837. //    MyCaos.PPCSize        =    0;
  838.     MyCaos.a0        =(ULONG) freeList;
  839.     MyCaos.a1        =(ULONG) memoryBlock;
  840.     MyCaos.d0        =(ULONG) byteSize;
  841.     MyCaos.caos_Un.Offset    =    (-192);
  842.     MyCaos.a6        =(ULONG) SysBase;    
  843.     PPCCallOS(&MyCaos);
  844. }
  845.  
  846. #define    Debug(flags)    _Debug(EXEC_BASE_NAME, flags)
  847.  
  848. static __inline void
  849. _Debug(void *SysBase, unsigned long flags)
  850. {
  851. struct Caos    MyCaos;
  852.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  853. //    MyCaos.M68kStart    =    NULL;
  854. //    MyCaos.M68kSize        =    0;
  855.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  856. //    MyCaos.PPCStart        =    NULL;
  857. //    MyCaos.PPCSize        =    0;
  858.     MyCaos.d0        =(ULONG) flags;
  859.     MyCaos.caos_Un.Offset    =    (-114);
  860.     MyCaos.a6        =(ULONG) SysBase;    
  861.     PPCCallOS(&MyCaos);
  862. }
  863.  
  864. #define    DeleteIORequest(iorequest)    _DeleteIORequest(EXEC_BASE_NAME, iorequest)
  865.  
  866. static __inline void
  867. _DeleteIORequest(void *SysBase, APTR iorequest)
  868. {
  869. struct Caos    MyCaos;
  870.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  871. //    MyCaos.M68kStart    =    NULL;
  872. //    MyCaos.M68kSize        =    0;
  873.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  874. //    MyCaos.PPCStart        =    NULL;
  875. //    MyCaos.PPCSize        =    0;
  876.     MyCaos.a0        =(ULONG) iorequest;
  877.     MyCaos.caos_Un.Offset    =    (-660);
  878.     MyCaos.a6        =(ULONG) SysBase;    
  879.     PPCCallOS(&MyCaos);
  880. }
  881.  
  882. #define    DeleteMsgPort(port)    _DeleteMsgPort(EXEC_BASE_NAME, port)
  883.  
  884. static __inline void
  885. _DeleteMsgPort(void *SysBase, struct MsgPort *port)
  886. {
  887. struct Caos    MyCaos;
  888.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  889. //    MyCaos.M68kStart    =    NULL;
  890. //    MyCaos.M68kSize        =    0;
  891.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  892. //    MyCaos.PPCStart        =    NULL;
  893. //    MyCaos.PPCSize        =    0;
  894.     MyCaos.a0        =(ULONG) port;
  895.     MyCaos.caos_Un.Offset    =    (-672);
  896.     MyCaos.a6        =(ULONG) SysBase;    
  897.     PPCCallOS(&MyCaos);
  898. }
  899.  
  900. #define    DeletePool(poolHeader)    _DeletePool(EXEC_BASE_NAME, poolHeader)
  901.  
  902. static __inline void
  903. _DeletePool(void *SysBase, APTR poolHeader)
  904. {
  905. struct Caos    MyCaos;
  906.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  907. //    MyCaos.M68kStart    =    NULL;
  908. //    MyCaos.M68kSize        =    0;
  909.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  910. //    MyCaos.PPCStart        =    NULL;
  911. //    MyCaos.PPCSize        =    0;
  912.     MyCaos.a0        =(ULONG) poolHeader;
  913.     MyCaos.caos_Un.Offset    =    (-702);
  914.     MyCaos.a6        =(ULONG) SysBase;    
  915.     PPCCallOS(&MyCaos);
  916. }
  917.  
  918. #define    Disable()    _Disable(EXEC_BASE_NAME)
  919.  
  920. static __inline void
  921. _Disable(void *SysBase)
  922. {
  923. struct Caos    MyCaos;
  924.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  925. //    MyCaos.M68kStart    =    NULL;
  926. //    MyCaos.M68kSize        =    0;
  927.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  928. //    MyCaos.PPCStart        =    NULL;
  929. //    MyCaos.PPCSize        =    0;
  930.     MyCaos.caos_Un.Offset    =    (-120);
  931.     MyCaos.a6        =(ULONG) SysBase;    
  932.     PPCCallOS(&MyCaos);
  933. }
  934.  
  935. #define    DoIO(ioRequest)    _DoIO(EXEC_BASE_NAME, ioRequest)
  936.  
  937. static __inline BYTE
  938. _DoIO(void *SysBase, struct IORequest *ioRequest)
  939. {
  940. struct Caos    MyCaos;
  941.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  942. //    MyCaos.M68kStart    =    NULL;
  943. //    MyCaos.M68kSize        =    0;
  944.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  945. //    MyCaos.PPCStart        =    NULL;
  946. //    MyCaos.PPCSize        =    0;
  947.     MyCaos.a1        =(ULONG) ioRequest;
  948.     MyCaos.caos_Un.Offset    =    (-456);
  949.     MyCaos.a6        =(ULONG) SysBase;    
  950.     return((BYTE)PPCCallOS(&MyCaos));
  951. }
  952.  
  953. #define    Enable()    _Enable(EXEC_BASE_NAME)
  954.  
  955. static __inline void
  956. _Enable(void *SysBase)
  957. {
  958. struct Caos    MyCaos;
  959.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  960. //    MyCaos.M68kStart    =    NULL;
  961. //    MyCaos.M68kSize        =    0;
  962.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  963. //    MyCaos.PPCStart        =    NULL;
  964. //    MyCaos.PPCSize        =    0;
  965.     MyCaos.caos_Un.Offset    =    (-126);
  966.     MyCaos.a6        =(ULONG) SysBase;    
  967.     PPCCallOS(&MyCaos);
  968. }
  969.  
  970. #define    Enqueue(list, node)    _Enqueue(EXEC_BASE_NAME, list, node)
  971.  
  972. static __inline void
  973. _Enqueue(void *SysBase, struct List *list, struct Node *node)
  974. {
  975. struct Caos    MyCaos;
  976.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  977. //    MyCaos.M68kStart    =    NULL;
  978. //    MyCaos.M68kSize        =    0;
  979.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  980. //    MyCaos.PPCStart        =    NULL;
  981. //    MyCaos.PPCSize        =    0;
  982.     MyCaos.a0        =(ULONG) list;
  983.     MyCaos.a1        =(ULONG) node;
  984.     MyCaos.caos_Un.Offset    =    (-270);
  985.     MyCaos.a6        =(ULONG) SysBase;    
  986.     PPCCallOS(&MyCaos);
  987. }
  988.  
  989. #define    FindName(list, name)    _FindName(EXEC_BASE_NAME, list, name)
  990.  
  991. static __inline struct Node *
  992. _FindName(void *SysBase, struct List *list, UBYTE *name)
  993. {
  994. struct Caos    MyCaos;
  995.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  996. //    MyCaos.M68kStart    =    NULL;
  997. //    MyCaos.M68kSize        =    0;
  998.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  999. //    MyCaos.PPCStart        =    NULL;
  1000. //    MyCaos.PPCSize        =    0;
  1001.     MyCaos.a0        =(ULONG) list;
  1002.     MyCaos.a1        =(ULONG) name;
  1003.     MyCaos.caos_Un.Offset    =    (-276);
  1004.     MyCaos.a6        =(ULONG) SysBase;    
  1005.     return((struct Node *)PPCCallOS(&MyCaos));
  1006. }
  1007.  
  1008. #define    FindPort(name)    _FindPort(EXEC_BASE_NAME, name)
  1009.  
  1010. static __inline struct MsgPort *
  1011. _FindPort(void *SysBase, UBYTE *name)
  1012. {
  1013. struct Caos    MyCaos;
  1014.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1015. //    MyCaos.M68kStart    =    NULL;
  1016. //    MyCaos.M68kSize        =    0;
  1017.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1018. //    MyCaos.PPCStart        =    NULL;
  1019. //    MyCaos.PPCSize        =    0;
  1020.     MyCaos.a1        =(ULONG) name;
  1021.     MyCaos.caos_Un.Offset    =    (-390);
  1022.     MyCaos.a6        =(ULONG) SysBase;    
  1023.     return((struct MsgPort *)PPCCallOS(&MyCaos));
  1024. }
  1025.  
  1026. #define    FindResident(name)    _FindResident(EXEC_BASE_NAME, name)
  1027.  
  1028. static __inline struct Resident *
  1029. _FindResident(void *SysBase, UBYTE *name)
  1030. {
  1031. struct Caos    MyCaos;
  1032.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1033. //    MyCaos.M68kStart    =    NULL;
  1034. //    MyCaos.M68kSize        =    0;
  1035.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1036. //    MyCaos.PPCStart        =    NULL;
  1037. //    MyCaos.PPCSize        =    0;
  1038.     MyCaos.a1        =(ULONG) name;
  1039.     MyCaos.caos_Un.Offset    =    (-96);
  1040.     MyCaos.a6        =(ULONG) SysBase;    
  1041.     return((struct Resident *)PPCCallOS(&MyCaos));
  1042. }
  1043.  
  1044. #define    FindSemaphore(sigSem)    _FindSemaphore(EXEC_BASE_NAME, sigSem)
  1045.  
  1046. static __inline struct SignalSemaphore *
  1047. _FindSemaphore(void *SysBase, UBYTE *sigSem)
  1048. {
  1049. struct Caos    MyCaos;
  1050.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1051. //    MyCaos.M68kStart    =    NULL;
  1052. //    MyCaos.M68kSize        =    0;
  1053.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1054. //    MyCaos.PPCStart        =    NULL;
  1055. //    MyCaos.PPCSize        =    0;
  1056.     MyCaos.a1        =(ULONG) sigSem;
  1057.     MyCaos.caos_Un.Offset    =    (-594);
  1058.     MyCaos.a6        =(ULONG) SysBase;    
  1059.     return((struct SignalSemaphore *)PPCCallOS(&MyCaos));
  1060. }
  1061.  
  1062. #define    FindTask(name)    _FindTask(EXEC_BASE_NAME, name)
  1063.  
  1064. static __inline struct Task *
  1065. _FindTask(void *SysBase, UBYTE *name)
  1066. {
  1067. struct Caos    MyCaos;
  1068.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1069. //    MyCaos.M68kStart    =    NULL;
  1070. //    MyCaos.M68kSize        =    0;
  1071.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1072. //    MyCaos.PPCStart        =    NULL;
  1073. //    MyCaos.PPCSize        =    0;
  1074.     MyCaos.a1        =(ULONG) name;
  1075.     MyCaos.caos_Un.Offset    =    (-294);
  1076.     MyCaos.a6        =(ULONG) SysBase;    
  1077.     return((struct Task *)PPCCallOS(&MyCaos));
  1078. }
  1079.  
  1080. #define    Forbid()    _Forbid(EXEC_BASE_NAME)
  1081.  
  1082. static __inline void
  1083. _Forbid(void *SysBase)
  1084. {
  1085. struct Caos    MyCaos;
  1086.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1087. //    MyCaos.M68kStart    =    NULL;
  1088. //    MyCaos.M68kSize        =    0;
  1089.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1090. //    MyCaos.PPCStart        =    NULL;
  1091. //    MyCaos.PPCSize        =    0;
  1092.     MyCaos.caos_Un.Offset    =    (-132);
  1093.     MyCaos.a6        =(ULONG) SysBase;    
  1094.     PPCCallOS(&MyCaos);
  1095. }
  1096.  
  1097. #define    FreeEntry(entry)    _FreeEntry(EXEC_BASE_NAME, entry)
  1098.  
  1099. static __inline void
  1100. _FreeEntry(void *SysBase, struct MemList *entry)
  1101. {
  1102. struct Caos    MyCaos;
  1103.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1104. //    MyCaos.M68kStart    =    NULL;
  1105. //    MyCaos.M68kSize        =    0;
  1106.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1107. //    MyCaos.PPCStart        =    NULL;
  1108. //    MyCaos.PPCSize        =    0;
  1109.     MyCaos.a0        =(ULONG) entry;
  1110.     MyCaos.caos_Un.Offset    =    (-228);
  1111.     MyCaos.a6        =(ULONG) SysBase;    
  1112.     PPCCallOS(&MyCaos);
  1113. }
  1114.  
  1115. #define    FreeMem(memoryBlock, byteSize)    _FreeMem(EXEC_BASE_NAME, memoryBlock, byteSize)
  1116.  
  1117. static __inline void
  1118. _FreeMem(void *SysBase, APTR memoryBlock, unsigned long byteSize)
  1119. {
  1120. struct Caos    MyCaos;
  1121.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1122. //    MyCaos.M68kStart    =    NULL;
  1123. //    MyCaos.M68kSize        =    0;
  1124.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1125. //    MyCaos.PPCStart        =    NULL;
  1126. //    MyCaos.PPCSize        =    0;
  1127.     MyCaos.a1        =(ULONG) memoryBlock;
  1128.     MyCaos.d0        =(ULONG) byteSize;
  1129.     MyCaos.caos_Un.Offset    =    (-210);
  1130.     MyCaos.a6        =(ULONG) SysBase;    
  1131.     PPCCallOS(&MyCaos);
  1132. }
  1133.  
  1134. #define    FreePooled(poolHeader, memory, memSize)    _FreePooled(EXEC_BASE_NAME, poolHeader, memory, memSize)
  1135.  
  1136. static __inline void
  1137. _FreePooled(void *SysBase, APTR poolHeader, APTR memory, unsigned long memSize)
  1138. {
  1139. struct Caos    MyCaos;
  1140.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1141. //    MyCaos.M68kStart    =    NULL;
  1142. //    MyCaos.M68kSize        =    0;
  1143.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1144. //    MyCaos.PPCStart        =    NULL;
  1145. //    MyCaos.PPCSize        =    0;
  1146.     MyCaos.a0        =(ULONG) poolHeader;
  1147.     MyCaos.a1        =(ULONG) memory;
  1148.     MyCaos.d0        =(ULONG) memSize;
  1149.     MyCaos.caos_Un.Offset    =    (-714);
  1150.     MyCaos.a6        =(ULONG) SysBase;    
  1151.     PPCCallOS(&MyCaos);
  1152. }
  1153.  
  1154. #define    FreeSignal(signalNum)    _FreeSignal(EXEC_BASE_NAME, signalNum)
  1155.  
  1156. static __inline void
  1157. _FreeSignal(void *SysBase, long signalNum)
  1158. {
  1159. struct Caos    MyCaos;
  1160.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1161. //    MyCaos.M68kStart    =    NULL;
  1162. //    MyCaos.M68kSize        =    0;
  1163.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1164. //    MyCaos.PPCStart        =    NULL;
  1165. //    MyCaos.PPCSize        =    0;
  1166.     MyCaos.d0        =(ULONG) signalNum;
  1167.     MyCaos.caos_Un.Offset    =    (-336);
  1168.     MyCaos.a6        =(ULONG) SysBase;    
  1169.     PPCCallOS(&MyCaos);
  1170. }
  1171.  
  1172. #define    FreeTrap(trapNum)    _FreeTrap(EXEC_BASE_NAME, trapNum)
  1173.  
  1174. static __inline void
  1175. _FreeTrap(void *SysBase, long trapNum)
  1176. {
  1177. struct Caos    MyCaos;
  1178.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1179. //    MyCaos.M68kStart    =    NULL;
  1180. //    MyCaos.M68kSize        =    0;
  1181.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1182. //    MyCaos.PPCStart        =    NULL;
  1183. //    MyCaos.PPCSize        =    0;
  1184.     MyCaos.d0        =(ULONG) trapNum;
  1185.     MyCaos.caos_Un.Offset    =    (-348);
  1186.     MyCaos.a6        =(ULONG) SysBase;    
  1187.     PPCCallOS(&MyCaos);
  1188. }
  1189.  
  1190. #define    FreeVec(memoryBlock)    _FreeVec(EXEC_BASE_NAME, memoryBlock)
  1191.  
  1192. static __inline void
  1193. _FreeVec(void *SysBase, APTR memoryBlock)
  1194. {
  1195. struct Caos    MyCaos;
  1196.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1197. //    MyCaos.M68kStart    =    NULL;
  1198. //    MyCaos.M68kSize        =    0;
  1199.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1200. //    MyCaos.PPCStart        =    NULL;
  1201. //    MyCaos.PPCSize        =    0;
  1202.     MyCaos.a1        =(ULONG) memoryBlock;
  1203.     MyCaos.caos_Un.Offset    =    (-690);
  1204.     MyCaos.a6        =(ULONG) SysBase;    
  1205.     PPCCallOS(&MyCaos);
  1206. }
  1207.  
  1208. #define    GetCC()    _GetCC(EXEC_BASE_NAME)
  1209.  
  1210. static __inline ULONG
  1211. _GetCC(void *SysBase)
  1212. {
  1213. struct Caos    MyCaos;
  1214.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1215. //    MyCaos.M68kStart    =    NULL;
  1216. //    MyCaos.M68kSize        =    0;
  1217.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1218. //    MyCaos.PPCStart        =    NULL;
  1219. //    MyCaos.PPCSize        =    0;
  1220.     MyCaos.caos_Un.Offset    =    (-528);
  1221.     MyCaos.a6        =(ULONG) SysBase;    
  1222.     return((ULONG)PPCCallOS(&MyCaos));
  1223. }
  1224.  
  1225. #define    GetMsg(port)    _GetMsg(EXEC_BASE_NAME, port)
  1226.  
  1227. static __inline struct Message *
  1228. _GetMsg(void *SysBase, struct MsgPort *port)
  1229. {
  1230. struct Caos    MyCaos;
  1231.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1232. //    MyCaos.M68kStart    =    NULL;
  1233. //    MyCaos.M68kSize        =    0;
  1234.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1235. //    MyCaos.PPCStart        =    NULL;
  1236. //    MyCaos.PPCSize        =    0;
  1237.     MyCaos.a0        =(ULONG) port;
  1238.     MyCaos.caos_Un.Offset    =    (-372);
  1239.     MyCaos.a6        =(ULONG) SysBase;    
  1240.     return((struct Message *)PPCCallOS(&MyCaos));
  1241. }
  1242.  
  1243. #define    InitCode(startClass, version)    _InitCode(EXEC_BASE_NAME, startClass, version)
  1244.  
  1245. static __inline void
  1246. _InitCode(void *SysBase, unsigned long startClass, unsigned long version)
  1247. {
  1248. struct Caos    MyCaos;
  1249.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1250. //    MyCaos.M68kStart    =    NULL;
  1251. //    MyCaos.M68kSize        =    0;
  1252.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1253. //    MyCaos.PPCStart        =    NULL;
  1254. //    MyCaos.PPCSize        =    0;
  1255.     MyCaos.d0        =(ULONG) startClass;
  1256.     MyCaos.d1        =(ULONG) version;
  1257.     MyCaos.caos_Un.Offset    =    (-72);
  1258.     MyCaos.a6        =(ULONG) SysBase;    
  1259.     PPCCallOS(&MyCaos);
  1260. }
  1261.  
  1262. #define    InitResident(resident, segList)    _InitResident(EXEC_BASE_NAME, resident, segList)
  1263.  
  1264. static __inline APTR
  1265. _InitResident(void *SysBase, struct Resident *resident, unsigned long segList)
  1266. {
  1267. struct Caos    MyCaos;
  1268.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1269. //    MyCaos.M68kStart    =    NULL;
  1270. //    MyCaos.M68kSize        =    0;
  1271.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1272. //    MyCaos.PPCStart        =    NULL;
  1273. //    MyCaos.PPCSize        =    0;
  1274.     MyCaos.a1        =(ULONG) resident;
  1275.     MyCaos.d1        =(ULONG) segList;
  1276.     MyCaos.caos_Un.Offset    =    (-102);
  1277.     MyCaos.a6        =(ULONG) SysBase;    
  1278.     return((APTR)PPCCallOS(&MyCaos));
  1279. }
  1280.  
  1281. #define    InitSemaphore(sigSem)    _InitSemaphore(EXEC_BASE_NAME, sigSem)
  1282.  
  1283. static __inline void
  1284. _InitSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  1285. {
  1286. struct Caos    MyCaos;
  1287.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1288. //    MyCaos.M68kStart    =    NULL;
  1289. //    MyCaos.M68kSize        =    0;
  1290.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1291. //    MyCaos.PPCStart        =    NULL;
  1292. //    MyCaos.PPCSize        =    0;
  1293.     MyCaos.a0        =(ULONG) sigSem;
  1294.     MyCaos.caos_Un.Offset    =    (-558);
  1295.     MyCaos.a6        =(ULONG) SysBase;    
  1296.     PPCCallOS(&MyCaos);
  1297. }
  1298.  
  1299. #define    InitStruct(initTable, memory, size)    _InitStruct(EXEC_BASE_NAME, initTable, memory, size)
  1300.  
  1301. static __inline void
  1302. _InitStruct(void *SysBase, APTR initTable, APTR memory, unsigned long size)
  1303. {
  1304. struct Caos    MyCaos;
  1305.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1306. //    MyCaos.M68kStart    =    NULL;
  1307. //    MyCaos.M68kSize        =    0;
  1308.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1309. //    MyCaos.PPCStart        =    NULL;
  1310. //    MyCaos.PPCSize        =    0;
  1311.     MyCaos.a1        =(ULONG) initTable;
  1312.     MyCaos.a2        =(ULONG) memory;
  1313.     MyCaos.d0        =(ULONG) size;
  1314.     MyCaos.caos_Un.Offset    =    (-78);
  1315.     MyCaos.a6        =(ULONG) SysBase;    
  1316.     PPCCallOS(&MyCaos);
  1317. }
  1318.  
  1319. #define    Insert(list, node, pred)    _Insert(EXEC_BASE_NAME, list, node, pred)
  1320.  
  1321. static __inline void
  1322. _Insert(void *SysBase, struct List *list, struct Node *node, struct Node *pred)
  1323. {
  1324. struct Caos    MyCaos;
  1325.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1326. //    MyCaos.M68kStart    =    NULL;
  1327. //    MyCaos.M68kSize        =    0;
  1328.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1329. //    MyCaos.PPCStart        =    NULL;
  1330. //    MyCaos.PPCSize        =    0;
  1331.     MyCaos.a0        =(ULONG) list;
  1332.     MyCaos.a1        =(ULONG) node;
  1333.     MyCaos.a2        =(ULONG) pred;
  1334.     MyCaos.caos_Un.Offset    =    (-234);
  1335.     MyCaos.a6        =(ULONG) SysBase;    
  1336.     PPCCallOS(&MyCaos);
  1337. }
  1338.  
  1339. #define    MakeFunctions(target, functionArray, funcDispBase)    _MakeFunctions(EXEC_BASE_NAME, target, functionArray, funcDispBase)
  1340.  
  1341. static __inline void
  1342. _MakeFunctions(void *SysBase, APTR target, APTR functionArray, unsigned long funcDispBase)
  1343. {
  1344. struct Caos    MyCaos;
  1345.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1346. //    MyCaos.M68kStart    =    NULL;
  1347. //    MyCaos.M68kSize        =    0;
  1348.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1349. //    MyCaos.PPCStart        =    NULL;
  1350. //    MyCaos.PPCSize        =    0;
  1351.     MyCaos.a0        =(ULONG) target;
  1352.     MyCaos.a1        =(ULONG) functionArray;
  1353.     MyCaos.a2        =(ULONG) funcDispBase;
  1354.     MyCaos.caos_Un.Offset    =    (-90);
  1355.     MyCaos.a6        =(ULONG) SysBase;    
  1356.     PPCCallOS(&MyCaos);
  1357. }
  1358.  
  1359. #define    MakeLibrary(funcInit, structInit, libInit, dataSize, segList)    _MakeLibrary(EXEC_BASE_NAME, funcInit, structInit, libInit, dataSize, segList)
  1360.  
  1361. static __inline struct Library *
  1362. _MakeLibrary(void *SysBase, APTR funcInit, APTR structInit, unsigned long (*libInit)(), unsigned long dataSize, unsigned long segList)
  1363. {
  1364. struct Caos    MyCaos;
  1365.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1366. //    MyCaos.M68kStart    =    NULL;
  1367. //    MyCaos.M68kSize        =    0;
  1368.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1369. //    MyCaos.PPCStart        =    NULL;
  1370. //    MyCaos.PPCSize        =    0;
  1371.     MyCaos.a0        =(ULONG) funcInit;
  1372.     MyCaos.a1        =(ULONG) structInit;
  1373.     MyCaos.a2        =(ULONG) libInit;
  1374.     MyCaos.d0        =(ULONG) dataSize;
  1375.     MyCaos.d1        =(ULONG) segList;
  1376.     MyCaos.caos_Un.Offset    =    (-84);
  1377.     MyCaos.a6        =(ULONG) SysBase;    
  1378.     return((struct Library *)PPCCallOS(&MyCaos));
  1379. }
  1380.  
  1381. #define    ObtainQuickVector(interruptCode)    _ObtainQuickVector(EXEC_BASE_NAME, interruptCode)
  1382.  
  1383. static __inline ULONG
  1384. _ObtainQuickVector(void *SysBase, APTR interruptCode)
  1385. {
  1386. struct Caos    MyCaos;
  1387.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1388. //    MyCaos.M68kStart    =    NULL;
  1389. //    MyCaos.M68kSize        =    0;
  1390.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1391. //    MyCaos.PPCStart        =    NULL;
  1392. //    MyCaos.PPCSize        =    0;
  1393.     MyCaos.a0        =(ULONG) interruptCode;
  1394.     MyCaos.caos_Un.Offset    =    (-786);
  1395.     MyCaos.a6        =(ULONG) SysBase;    
  1396.     return((ULONG)PPCCallOS(&MyCaos));
  1397. }
  1398.  
  1399. #define    ObtainSemaphore(sigSem)    _ObtainSemaphore(EXEC_BASE_NAME, sigSem)
  1400.  
  1401. static __inline void
  1402. _ObtainSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  1403. {
  1404. struct Caos    MyCaos;
  1405.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1406. //    MyCaos.M68kStart    =    NULL;
  1407. //    MyCaos.M68kSize        =    0;
  1408.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1409. //    MyCaos.PPCStart        =    NULL;
  1410. //    MyCaos.PPCSize        =    0;
  1411.     MyCaos.a0        =(ULONG) sigSem;
  1412.     MyCaos.caos_Un.Offset    =    (-564);
  1413.     MyCaos.a6        =(ULONG) SysBase;    
  1414.     PPCCallOS(&MyCaos);
  1415. }
  1416.  
  1417. #define    ObtainSemaphoreList(sigSem)    _ObtainSemaphoreList(EXEC_BASE_NAME, sigSem)
  1418.  
  1419. static __inline void
  1420. _ObtainSemaphoreList(void *SysBase, struct List *sigSem)
  1421. {
  1422. struct Caos    MyCaos;
  1423.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1424. //    MyCaos.M68kStart    =    NULL;
  1425. //    MyCaos.M68kSize        =    0;
  1426.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1427. //    MyCaos.PPCStart        =    NULL;
  1428. //    MyCaos.PPCSize        =    0;
  1429.     MyCaos.a0        =(ULONG) sigSem;
  1430.     MyCaos.caos_Un.Offset    =    (-582);
  1431.     MyCaos.a6        =(ULONG) SysBase;    
  1432.     PPCCallOS(&MyCaos);
  1433. }
  1434.  
  1435. #define    ObtainSemaphoreShared(sigSem)    _ObtainSemaphoreShared(EXEC_BASE_NAME, sigSem)
  1436.  
  1437. static __inline void
  1438. _ObtainSemaphoreShared(void *SysBase, struct SignalSemaphore *sigSem)
  1439. {
  1440. struct Caos    MyCaos;
  1441.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1442. //    MyCaos.M68kStart    =    NULL;
  1443. //    MyCaos.M68kSize        =    0;
  1444.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1445. //    MyCaos.PPCStart        =    NULL;
  1446. //    MyCaos.PPCSize        =    0;
  1447.     MyCaos.a0        =(ULONG) sigSem;
  1448.     MyCaos.caos_Un.Offset    =    (-678);
  1449.     MyCaos.a6        =(ULONG) SysBase;    
  1450.     PPCCallOS(&MyCaos);
  1451. }
  1452.  
  1453. #define    OldOpenLibrary(libName)    _OldOpenLibrary(EXEC_BASE_NAME, libName)
  1454.  
  1455. static __inline struct Library *
  1456. _OldOpenLibrary(void *SysBase, UBYTE *libName)
  1457. {
  1458. struct Caos    MyCaos;
  1459.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1460. //    MyCaos.M68kStart    =    NULL;
  1461. //    MyCaos.M68kSize        =    0;
  1462.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1463. //    MyCaos.PPCStart        =    NULL;
  1464. //    MyCaos.PPCSize        =    0;
  1465.     MyCaos.a1        =(ULONG) libName;
  1466.     MyCaos.caos_Un.Offset    =    (-408);
  1467.     MyCaos.a6        =(ULONG) SysBase;    
  1468.     return((struct Library *)PPCCallOS(&MyCaos));
  1469. }
  1470.  
  1471. #define    OpenDevice(devName, unit, ioRequest, flags)    _OpenDevice(EXEC_BASE_NAME, devName, unit, ioRequest, flags)
  1472.  
  1473. static __inline BYTE
  1474. _OpenDevice(void *SysBase, UBYTE *devName, unsigned long unit, struct IORequest *ioRequest, unsigned long flags)
  1475. {
  1476. struct Caos    MyCaos;
  1477.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1478. //    MyCaos.M68kStart    =    NULL;
  1479. //    MyCaos.M68kSize        =    0;
  1480.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1481. //    MyCaos.PPCStart        =    NULL;
  1482. //    MyCaos.PPCSize        =    0;
  1483.     MyCaos.a0        =(ULONG) devName;
  1484.     MyCaos.d0        =(ULONG) unit;
  1485.     MyCaos.a1        =(ULONG) ioRequest;
  1486.     MyCaos.d1        =(ULONG) flags;
  1487.     MyCaos.caos_Un.Offset    =    (-444);
  1488.     MyCaos.a6        =(ULONG) SysBase;    
  1489.     return((BYTE)PPCCallOS(&MyCaos));
  1490. }
  1491.  
  1492. #define    OpenLibrary(libName, version)    _OpenLibrary(EXEC_BASE_NAME, libName, version)
  1493.  
  1494. static __inline struct Library *
  1495. _OpenLibrary(void *SysBase, UBYTE *libName, unsigned long version)
  1496. {
  1497. struct Caos    MyCaos;
  1498.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1499. //    MyCaos.M68kStart    =    NULL;
  1500. //    MyCaos.M68kSize        =    0;
  1501.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1502. //    MyCaos.PPCStart        =    NULL;
  1503. //    MyCaos.PPCSize        =    0;
  1504.     MyCaos.a1        =(ULONG) libName;
  1505.     MyCaos.d0        =(ULONG) version;
  1506.     MyCaos.caos_Un.Offset    =    (-552);
  1507.     MyCaos.a6        =(ULONG) SysBase;    
  1508.     return((struct Library *)PPCCallOS(&MyCaos));
  1509. }
  1510.  
  1511. #define    OpenResource(resName)    _OpenResource(EXEC_BASE_NAME, resName)
  1512.  
  1513. static __inline APTR
  1514. _OpenResource(void *SysBase, UBYTE *resName)
  1515. {
  1516. struct Caos    MyCaos;
  1517.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1518. //    MyCaos.M68kStart    =    NULL;
  1519. //    MyCaos.M68kSize        =    0;
  1520.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1521. //    MyCaos.PPCStart        =    NULL;
  1522. //    MyCaos.PPCSize        =    0;
  1523.     MyCaos.a1        =(ULONG) resName;
  1524.     MyCaos.caos_Un.Offset    =    (-498);
  1525.     MyCaos.a6        =(ULONG) SysBase;    
  1526.     return((APTR)PPCCallOS(&MyCaos));
  1527. }
  1528.  
  1529. #define    Permit()    _Permit(EXEC_BASE_NAME)
  1530.  
  1531. static __inline void
  1532. _Permit(void *SysBase)
  1533. {
  1534. struct Caos    MyCaos;
  1535.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1536. //    MyCaos.M68kStart    =    NULL;
  1537. //    MyCaos.M68kSize        =    0;
  1538.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1539. //    MyCaos.PPCStart        =    NULL;
  1540. //    MyCaos.PPCSize        =    0;
  1541.     MyCaos.caos_Un.Offset    =    (-138);
  1542.     MyCaos.a6        =(ULONG) SysBase;    
  1543.     PPCCallOS(&MyCaos);
  1544. }
  1545.  
  1546. #define    Procure(sigSem, bidMsg)    _Procure(EXEC_BASE_NAME, sigSem, bidMsg)
  1547.  
  1548. static __inline ULONG
  1549. _Procure(void *SysBase, struct SignalSemaphore *sigSem, struct SemaphoreMessage *bidMsg)
  1550. {
  1551. struct Caos    MyCaos;
  1552.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1553. //    MyCaos.M68kStart    =    NULL;
  1554. //    MyCaos.M68kSize        =    0;
  1555.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1556. //    MyCaos.PPCStart        =    NULL;
  1557. //    MyCaos.PPCSize        =    0;
  1558.     MyCaos.a0        =(ULONG) sigSem;
  1559.     MyCaos.a1        =(ULONG) bidMsg;
  1560.     MyCaos.caos_Un.Offset    =    (-540);
  1561.     MyCaos.a6        =(ULONG) SysBase;    
  1562.     return((ULONG)PPCCallOS(&MyCaos));
  1563. }
  1564.  
  1565. #define    PutMsg(port, message)    _PutMsg(EXEC_BASE_NAME, port, message)
  1566.  
  1567. static __inline void
  1568. _PutMsg(void *SysBase, struct MsgPort *port, struct Message *message)
  1569. {
  1570. struct Caos    MyCaos;
  1571.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1572. //    MyCaos.M68kStart    =    NULL;
  1573. //    MyCaos.M68kSize        =    0;
  1574.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1575. //    MyCaos.PPCStart        =    NULL;
  1576. //    MyCaos.PPCSize        =    0;
  1577.     MyCaos.a0        =(ULONG) port;
  1578.     MyCaos.a1        =(ULONG) message;
  1579.     MyCaos.caos_Un.Offset    =    (-366);
  1580.     MyCaos.a6        =(ULONG) SysBase;    
  1581.     PPCCallOS(&MyCaos);
  1582. }
  1583.  
  1584. #define    RawDoFmt(formatString, dataStream, putChProc, putChData)    _RawDoFmt(EXEC_BASE_NAME, formatString, dataStream, putChProc, putChData)
  1585.  
  1586. static __inline APTR
  1587. _RawDoFmt(void *SysBase, UBYTE *formatString, APTR dataStream, void (*putChProc)(), APTR putChData)
  1588. {
  1589. struct Caos    MyCaos;
  1590.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1591. //    MyCaos.M68kStart    =    NULL;
  1592. //    MyCaos.M68kSize        =    0;
  1593.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1594. //    MyCaos.PPCStart        =    NULL;
  1595. //    MyCaos.PPCSize        =    0;
  1596.     MyCaos.a0        =(ULONG) formatString;
  1597.     MyCaos.a1        =(ULONG) dataStream;
  1598.     MyCaos.a2        =(ULONG) putChProc;
  1599.     MyCaos.a3        =(ULONG) putChData;
  1600.     MyCaos.caos_Un.Offset    =    (-522);
  1601.     MyCaos.a6        =(ULONG) SysBase;    
  1602.     return((APTR)PPCCallOS(&MyCaos));
  1603. }
  1604.  
  1605. #define    ReleaseSemaphore(sigSem)    _ReleaseSemaphore(EXEC_BASE_NAME, sigSem)
  1606.  
  1607. static __inline void
  1608. _ReleaseSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  1609. {
  1610. struct Caos    MyCaos;
  1611.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1612. //    MyCaos.M68kStart    =    NULL;
  1613. //    MyCaos.M68kSize        =    0;
  1614.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1615. //    MyCaos.PPCStart        =    NULL;
  1616. //    MyCaos.PPCSize        =    0;
  1617.     MyCaos.a0        =(ULONG) sigSem;
  1618.     MyCaos.caos_Un.Offset    =    (-570);
  1619.     MyCaos.a6        =(ULONG) SysBase;    
  1620.     PPCCallOS(&MyCaos);
  1621. }
  1622.  
  1623. #define    ReleaseSemaphoreList(sigSem)    _ReleaseSemaphoreList(EXEC_BASE_NAME, sigSem)
  1624.  
  1625. static __inline void
  1626. _ReleaseSemaphoreList(void *SysBase, struct List *sigSem)
  1627. {
  1628. struct Caos    MyCaos;
  1629.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1630. //    MyCaos.M68kStart    =    NULL;
  1631. //    MyCaos.M68kSize        =    0;
  1632.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1633. //    MyCaos.PPCStart        =    NULL;
  1634. //    MyCaos.PPCSize        =    0;
  1635.     MyCaos.a0        =(ULONG) sigSem;
  1636.     MyCaos.caos_Un.Offset    =    (-588);
  1637.     MyCaos.a6        =(ULONG) SysBase;    
  1638.     PPCCallOS(&MyCaos);
  1639. }
  1640.  
  1641. #define    RemDevice(device)    _RemDevice(EXEC_BASE_NAME, device)
  1642.  
  1643. static __inline void
  1644. _RemDevice(void *SysBase, struct Device *device)
  1645. {
  1646. struct Caos    MyCaos;
  1647.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1648. //    MyCaos.M68kStart    =    NULL;
  1649. //    MyCaos.M68kSize        =    0;
  1650.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1651. //    MyCaos.PPCStart        =    NULL;
  1652. //    MyCaos.PPCSize        =    0;
  1653.     MyCaos.a1        =(ULONG) device;
  1654.     MyCaos.caos_Un.Offset    =    (-438);
  1655.     MyCaos.a6        =(ULONG) SysBase;    
  1656.     PPCCallOS(&MyCaos);
  1657. }
  1658.  
  1659. #define    RemHead(list)    _RemHead(EXEC_BASE_NAME, list)
  1660.  
  1661. static __inline struct Node *
  1662. _RemHead(void *SysBase, struct List *list)
  1663. {
  1664. struct Caos    MyCaos;
  1665.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1666. //    MyCaos.M68kStart    =    NULL;
  1667. //    MyCaos.M68kSize        =    0;
  1668.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1669. //    MyCaos.PPCStart        =    NULL;
  1670. //    MyCaos.PPCSize        =    0;
  1671.     MyCaos.a0        =(ULONG) list;
  1672.     MyCaos.caos_Un.Offset    =    (-258);
  1673.     MyCaos.a6        =(ULONG) SysBase;    
  1674.     return((struct Node *)PPCCallOS(&MyCaos));
  1675. }
  1676.  
  1677. #define    RemIntServer(intNumber, interrupt)    _RemIntServer(EXEC_BASE_NAME, intNumber, interrupt)
  1678.  
  1679. static __inline void
  1680. _RemIntServer(void *SysBase, long intNumber, struct Interrupt *interrupt)
  1681. {
  1682. struct Caos    MyCaos;
  1683.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1684. //    MyCaos.M68kStart    =    NULL;
  1685. //    MyCaos.M68kSize        =    0;
  1686.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1687. //    MyCaos.PPCStart        =    NULL;
  1688. //    MyCaos.PPCSize        =    0;
  1689.     MyCaos.d0        =(ULONG) intNumber;
  1690.     MyCaos.a1        =(ULONG) interrupt;
  1691.     MyCaos.caos_Un.Offset    =    (-174);
  1692.     MyCaos.a6        =(ULONG) SysBase;    
  1693.     PPCCallOS(&MyCaos);
  1694. }
  1695.  
  1696. #define    RemLibrary(library)    _RemLibrary(EXEC_BASE_NAME, library)
  1697.  
  1698. static __inline void
  1699. _RemLibrary(void *SysBase, struct Library *library)
  1700. {
  1701. struct Caos    MyCaos;
  1702.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1703. //    MyCaos.M68kStart    =    NULL;
  1704. //    MyCaos.M68kSize        =    0;
  1705.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1706. //    MyCaos.PPCStart        =    NULL;
  1707. //    MyCaos.PPCSize        =    0;
  1708.     MyCaos.a1        =(ULONG) library;
  1709.     MyCaos.caos_Un.Offset    =    (-402);
  1710.     MyCaos.a6        =(ULONG) SysBase;    
  1711.     PPCCallOS(&MyCaos);
  1712. }
  1713.  
  1714. #define    RemMemHandler(memhand)    _RemMemHandler(EXEC_BASE_NAME, memhand)
  1715.  
  1716. static __inline void
  1717. _RemMemHandler(void *SysBase, struct Interrupt *memhand)
  1718. {
  1719. struct Caos    MyCaos;
  1720.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1721. //    MyCaos.M68kStart    =    NULL;
  1722. //    MyCaos.M68kSize        =    0;
  1723.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1724. //    MyCaos.PPCStart        =    NULL;
  1725. //    MyCaos.PPCSize        =    0;
  1726.     MyCaos.a1        =(ULONG) memhand;
  1727.     MyCaos.caos_Un.Offset    =    (-780);
  1728.     MyCaos.a6        =(ULONG) SysBase;    
  1729.     PPCCallOS(&MyCaos);
  1730. }
  1731.  
  1732. #define    RemPort(port)    _RemPort(EXEC_BASE_NAME, port)
  1733.  
  1734. static __inline void
  1735. _RemPort(void *SysBase, struct MsgPort *port)
  1736. {
  1737. struct Caos    MyCaos;
  1738.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1739. //    MyCaos.M68kStart    =    NULL;
  1740. //    MyCaos.M68kSize        =    0;
  1741.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1742. //    MyCaos.PPCStart        =    NULL;
  1743. //    MyCaos.PPCSize        =    0;
  1744.     MyCaos.a1        =(ULONG) port;
  1745.     MyCaos.caos_Un.Offset    =    (-360);
  1746.     MyCaos.a6        =(ULONG) SysBase;    
  1747.     PPCCallOS(&MyCaos);
  1748. }
  1749.  
  1750. #define    RemResource(resource)    _RemResource(EXEC_BASE_NAME, resource)
  1751.  
  1752. static __inline void
  1753. _RemResource(void *SysBase, APTR resource)
  1754. {
  1755. struct Caos    MyCaos;
  1756.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1757. //    MyCaos.M68kStart    =    NULL;
  1758. //    MyCaos.M68kSize        =    0;
  1759.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1760. //    MyCaos.PPCStart        =    NULL;
  1761. //    MyCaos.PPCSize        =    0;
  1762.     MyCaos.a1        =(ULONG) resource;
  1763.     MyCaos.caos_Un.Offset    =    (-492);
  1764.     MyCaos.a6        =(ULONG) SysBase;    
  1765.     PPCCallOS(&MyCaos);
  1766. }
  1767.  
  1768. #define    RemSemaphore(sigSem)    _RemSemaphore(EXEC_BASE_NAME, sigSem)
  1769.  
  1770. static __inline void
  1771. _RemSemaphore(void *SysBase, struct SignalSemaphore *sigSem)
  1772. {
  1773. struct Caos    MyCaos;
  1774.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1775. //    MyCaos.M68kStart    =    NULL;
  1776. //    MyCaos.M68kSize        =    0;
  1777.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1778. //    MyCaos.PPCStart        =    NULL;
  1779. //    MyCaos.PPCSize        =    0;
  1780.     MyCaos.a1        =(ULONG) sigSem;
  1781.     MyCaos.caos_Un.Offset    =    (-606);
  1782.     MyCaos.a6        =(ULONG) SysBase;    
  1783.     PPCCallOS(&MyCaos);
  1784. }
  1785.  
  1786. #define    RemTail(list)    _RemTail(EXEC_BASE_NAME, list)
  1787.  
  1788. static __inline struct Node *
  1789. _RemTail(void *SysBase, struct List *list)
  1790. {
  1791. struct Caos    MyCaos;
  1792.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1793. //    MyCaos.M68kStart    =    NULL;
  1794. //    MyCaos.M68kSize        =    0;
  1795.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1796. //    MyCaos.PPCStart        =    NULL;
  1797. //    MyCaos.PPCSize        =    0;
  1798.     MyCaos.a0        =(ULONG) list;
  1799.     MyCaos.caos_Un.Offset    =    (-264);
  1800.     MyCaos.a6        =(ULONG) SysBase;    
  1801.     return((struct Node *)PPCCallOS(&MyCaos));
  1802. }
  1803.  
  1804. #define    RemTask(task)    _RemTask(EXEC_BASE_NAME, task)
  1805.  
  1806. static __inline void
  1807. _RemTask(void *SysBase, struct Task *task)
  1808. {
  1809. struct Caos    MyCaos;
  1810.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1811. //    MyCaos.M68kStart    =    NULL;
  1812. //    MyCaos.M68kSize        =    0;
  1813.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1814. //    MyCaos.PPCStart        =    NULL;
  1815. //    MyCaos.PPCSize        =    0;
  1816.     MyCaos.a1        =(ULONG) task;
  1817.     MyCaos.caos_Un.Offset    =    (-288);
  1818.     MyCaos.a6        =(ULONG) SysBase;    
  1819.     PPCCallOS(&MyCaos);
  1820. }
  1821.  
  1822. #define    Remove(node)    _Remove(EXEC_BASE_NAME, node)
  1823.  
  1824. static __inline void
  1825. _Remove(void *SysBase, struct Node *node)
  1826. {
  1827. struct Caos    MyCaos;
  1828.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1829. //    MyCaos.M68kStart    =    NULL;
  1830. //    MyCaos.M68kSize        =    0;
  1831.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1832. //    MyCaos.PPCStart        =    NULL;
  1833. //    MyCaos.PPCSize        =    0;
  1834.     MyCaos.a1        =(ULONG) node;
  1835.     MyCaos.caos_Un.Offset    =    (-252);
  1836.     MyCaos.a6        =(ULONG) SysBase;    
  1837.     PPCCallOS(&MyCaos);
  1838. }
  1839.  
  1840. #define    ReplyMsg(message)    _ReplyMsg(EXEC_BASE_NAME, message)
  1841.  
  1842. static __inline void
  1843. _ReplyMsg(void *SysBase, struct Message *message)
  1844. {
  1845. struct Caos    MyCaos;
  1846.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1847. //    MyCaos.M68kStart    =    NULL;
  1848. //    MyCaos.M68kSize        =    0;
  1849.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1850. //    MyCaos.PPCStart        =    NULL;
  1851. //    MyCaos.PPCSize        =    0;
  1852.     MyCaos.a1        =(ULONG) message;
  1853.     MyCaos.caos_Un.Offset    =    (-378);
  1854.     MyCaos.a6        =(ULONG) SysBase;    
  1855.     PPCCallOS(&MyCaos);
  1856. }
  1857.  
  1858. #define    SendIO(ioRequest)    _SendIO(EXEC_BASE_NAME, ioRequest)
  1859.  
  1860. static __inline void
  1861. _SendIO(void *SysBase, struct IORequest *ioRequest)
  1862. {
  1863. struct Caos    MyCaos;
  1864.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1865. //    MyCaos.M68kStart    =    NULL;
  1866. //    MyCaos.M68kSize        =    0;
  1867.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1868. //    MyCaos.PPCStart        =    NULL;
  1869. //    MyCaos.PPCSize        =    0;
  1870.     MyCaos.a1        =(ULONG) ioRequest;
  1871.     MyCaos.caos_Un.Offset    =    (-462);
  1872.     MyCaos.a6        =(ULONG) SysBase;    
  1873.     PPCCallOS(&MyCaos);
  1874. }
  1875.  
  1876. #define    SetExcept(newSignals, signalSet)    _SetExcept(EXEC_BASE_NAME, newSignals, signalSet)
  1877.  
  1878. static __inline ULONG
  1879. _SetExcept(void *SysBase, unsigned long newSignals, unsigned long signalSet)
  1880. {
  1881. struct Caos    MyCaos;
  1882.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1883. //    MyCaos.M68kStart    =    NULL;
  1884. //    MyCaos.M68kSize        =    0;
  1885.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1886. //    MyCaos.PPCStart        =    NULL;
  1887. //    MyCaos.PPCSize        =    0;
  1888.     MyCaos.d0        =(ULONG) newSignals;
  1889.     MyCaos.d1        =(ULONG) signalSet;
  1890.     MyCaos.caos_Un.Offset    =    (-312);
  1891.     MyCaos.a6        =(ULONG) SysBase;    
  1892.     return((ULONG)PPCCallOS(&MyCaos));
  1893. }
  1894.  
  1895. #define    SetFunction(library, funcOffset, newFunction)    _SetFunction(EXEC_BASE_NAME, library, funcOffset, newFunction)
  1896.  
  1897. static __inline APTR
  1898. _SetFunction(void *SysBase, struct Library *library, long funcOffset, unsigned long (*newFunction)())
  1899. {
  1900. struct Caos    MyCaos;
  1901.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1902. //    MyCaos.M68kStart    =    NULL;
  1903. //    MyCaos.M68kSize        =    0;
  1904.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1905. //    MyCaos.PPCStart        =    NULL;
  1906. //    MyCaos.PPCSize        =    0;
  1907.     MyCaos.a1        =(ULONG) library;
  1908.     MyCaos.a0        =(ULONG) funcOffset;
  1909.     MyCaos.d0        =(ULONG) newFunction;
  1910.     MyCaos.caos_Un.Offset    =    (-420);
  1911.     MyCaos.a6        =(ULONG) SysBase;    
  1912.     return((APTR)PPCCallOS(&MyCaos));
  1913. }
  1914.  
  1915. #define    SetIntVector(intNumber, interrupt)    _SetIntVector(EXEC_BASE_NAME, intNumber, interrupt)
  1916.  
  1917. static __inline struct Interrupt *
  1918. _SetIntVector(void *SysBase, long intNumber, struct Interrupt *interrupt)
  1919. {
  1920. struct Caos    MyCaos;
  1921.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1922. //    MyCaos.M68kStart    =    NULL;
  1923. //    MyCaos.M68kSize        =    0;
  1924.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1925. //    MyCaos.PPCStart        =    NULL;
  1926. //    MyCaos.PPCSize        =    0;
  1927.     MyCaos.d0        =(ULONG) intNumber;
  1928.     MyCaos.a1        =(ULONG) interrupt;
  1929.     MyCaos.caos_Un.Offset    =    (-162);
  1930.     MyCaos.a6        =(ULONG) SysBase;    
  1931.     return((struct Interrupt *)PPCCallOS(&MyCaos));
  1932. }
  1933.  
  1934. #define    SetSR(newSR, mask)    _SetSR(EXEC_BASE_NAME, newSR, mask)
  1935.  
  1936. static __inline ULONG
  1937. _SetSR(void *SysBase, unsigned long newSR, unsigned long mask)
  1938. {
  1939. struct Caos    MyCaos;
  1940.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1941. //    MyCaos.M68kStart    =    NULL;
  1942. //    MyCaos.M68kSize        =    0;
  1943.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1944. //    MyCaos.PPCStart        =    NULL;
  1945. //    MyCaos.PPCSize        =    0;
  1946.     MyCaos.d0        =(ULONG) newSR;
  1947.     MyCaos.d1        =(ULONG) mask;
  1948.     MyCaos.caos_Un.Offset    =    (-144);
  1949.     MyCaos.a6        =(ULONG) SysBase;    
  1950.     return((ULONG)PPCCallOS(&MyCaos));
  1951. }
  1952.  
  1953. #define    SetSignal(newSignals, signalSet)    _SetSignal(EXEC_BASE_NAME, newSignals, signalSet)
  1954.  
  1955. static __inline ULONG
  1956. _SetSignal(void *SysBase, unsigned long newSignals, unsigned long signalSet)
  1957. {
  1958. struct Caos    MyCaos;
  1959.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1960. //    MyCaos.M68kStart    =    NULL;
  1961. //    MyCaos.M68kSize        =    0;
  1962.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1963. //    MyCaos.PPCStart        =    NULL;
  1964. //    MyCaos.PPCSize        =    0;
  1965.     MyCaos.d0        =(ULONG) newSignals;
  1966.     MyCaos.d1        =(ULONG) signalSet;
  1967.     MyCaos.caos_Un.Offset    =    (-306);
  1968.     MyCaos.a6        =(ULONG) SysBase;    
  1969.     return((ULONG)PPCCallOS(&MyCaos));
  1970. }
  1971.  
  1972. #define    SetTaskPri(task, priority)    _SetTaskPri(EXEC_BASE_NAME, task, priority)
  1973.  
  1974. static __inline BYTE
  1975. _SetTaskPri(void *SysBase, struct Task *task, long priority)
  1976. {
  1977. struct Caos    MyCaos;
  1978.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1979. //    MyCaos.M68kStart    =    NULL;
  1980. //    MyCaos.M68kSize        =    0;
  1981.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1982. //    MyCaos.PPCStart        =    NULL;
  1983. //    MyCaos.PPCSize        =    0;
  1984.     MyCaos.a1        =(ULONG) task;
  1985.     MyCaos.d0        =(ULONG) priority;
  1986.     MyCaos.caos_Un.Offset    =    (-300);
  1987.     MyCaos.a6        =(ULONG) SysBase;    
  1988.     return((BYTE)PPCCallOS(&MyCaos));
  1989. }
  1990.  
  1991. #define    Signal(task, signalSet)    _Signal(EXEC_BASE_NAME, task, signalSet)
  1992.  
  1993. static __inline void
  1994. _Signal(void *SysBase, struct Task *task, unsigned long signalSet)
  1995. {
  1996. struct Caos    MyCaos;
  1997.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1998. //    MyCaos.M68kStart    =    NULL;
  1999. //    MyCaos.M68kSize        =    0;
  2000.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2001. //    MyCaos.PPCStart        =    NULL;
  2002. //    MyCaos.PPCSize        =    0;
  2003.     MyCaos.a1        =(ULONG) task;
  2004.     MyCaos.d0        =(ULONG) signalSet;
  2005.     MyCaos.caos_Un.Offset    =    (-324);
  2006.     MyCaos.a6        =(ULONG) SysBase;    
  2007.     PPCCallOS(&MyCaos);
  2008. }
  2009.  
  2010. #define    StackSwap(newStack)    _StackSwap(EXEC_BASE_NAME, newStack)
  2011.  
  2012. static __inline void
  2013. _StackSwap(void *SysBase, struct StackSwapStruct *newStack)
  2014. {
  2015. struct Caos    MyCaos;
  2016.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2017. //    MyCaos.M68kStart    =    NULL;
  2018. //    MyCaos.M68kSize        =    0;
  2019.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2020. //    MyCaos.PPCStart        =    NULL;
  2021. //    MyCaos.PPCSize        =    0;
  2022.     MyCaos.a0        =(ULONG) newStack;
  2023.     MyCaos.caos_Un.Offset    =    (-732);
  2024.     MyCaos.a6        =(ULONG) SysBase;    
  2025.     PPCCallOS(&MyCaos);
  2026. }
  2027.  
  2028. #define    SumKickData()    _SumKickData(EXEC_BASE_NAME)
  2029.  
  2030. static __inline ULONG
  2031. _SumKickData(void *SysBase)
  2032. {
  2033. struct Caos    MyCaos;
  2034.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2035. //    MyCaos.M68kStart    =    NULL;
  2036. //    MyCaos.M68kSize        =    0;
  2037.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2038. //    MyCaos.PPCStart        =    NULL;
  2039. //    MyCaos.PPCSize        =    0;
  2040.     MyCaos.caos_Un.Offset    =    (-612);
  2041.     MyCaos.a6        =(ULONG) SysBase;    
  2042.     return((ULONG)PPCCallOS(&MyCaos));
  2043. }
  2044.  
  2045. #define    SumLibrary(library)    _SumLibrary(EXEC_BASE_NAME, library)
  2046.  
  2047. static __inline void
  2048. _SumLibrary(void *SysBase, struct Library *library)
  2049. {
  2050. struct Caos    MyCaos;
  2051.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2052. //    MyCaos.M68kStart    =    NULL;
  2053. //    MyCaos.M68kSize        =    0;
  2054.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2055. //    MyCaos.PPCStart        =    NULL;
  2056. //    MyCaos.PPCSize        =    0;
  2057.     MyCaos.a1        =(ULONG) library;
  2058.     MyCaos.caos_Un.Offset    =    (-426);
  2059.     MyCaos.a6        =(ULONG) SysBase;    
  2060.     PPCCallOS(&MyCaos);
  2061. }
  2062.  
  2063. #define    SuperState()    _SuperState(EXEC_BASE_NAME)
  2064.  
  2065. static __inline APTR
  2066. _SuperState(void *SysBase)
  2067. {
  2068. struct Caos    MyCaos;
  2069.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2070. //    MyCaos.M68kStart    =    NULL;
  2071. //    MyCaos.M68kSize        =    0;
  2072.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2073. //    MyCaos.PPCStart        =    NULL;
  2074. //    MyCaos.PPCSize        =    0;
  2075.     MyCaos.caos_Un.Offset    =    (-150);
  2076.     MyCaos.a6        =(ULONG) SysBase;    
  2077.     return((APTR)PPCCallOS(&MyCaos));
  2078. }
  2079.  
  2080. #define    Supervisor(userFunction)    _Supervisor(EXEC_BASE_NAME, userFunction)
  2081.  
  2082. static __inline ULONG
  2083. _Supervisor(void *SysBase, unsigned long (*userFunction)())
  2084. {
  2085. struct Caos    MyCaos;
  2086.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2087. //    MyCaos.M68kStart    =    NULL;
  2088. //    MyCaos.M68kSize        =    0;
  2089.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2090. //    MyCaos.PPCStart        =    NULL;
  2091. //    MyCaos.PPCSize        =    0;
  2092.     MyCaos.a5        =(ULONG) userFunction;
  2093.     MyCaos.caos_Un.Offset    =    (-30);
  2094.     MyCaos.a6        =(ULONG) SysBase;    
  2095.     return((ULONG)PPCCallOS(&MyCaos));
  2096. }
  2097.  
  2098. #define    TypeOfMem(address)    _TypeOfMem(EXEC_BASE_NAME, address)
  2099.  
  2100. static __inline ULONG
  2101. _TypeOfMem(void *SysBase, APTR address)
  2102. {
  2103. struct Caos    MyCaos;
  2104.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2105. //    MyCaos.M68kStart    =    NULL;
  2106. //    MyCaos.M68kSize        =    0;
  2107.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2108. //    MyCaos.PPCStart        =    NULL;
  2109. //    MyCaos.PPCSize        =    0;
  2110.     MyCaos.a1        =(ULONG) address;
  2111.     MyCaos.caos_Un.Offset    =    (-534);
  2112.     MyCaos.a6        =(ULONG) SysBase;    
  2113.     return((ULONG)PPCCallOS(&MyCaos));
  2114. }
  2115.  
  2116. #define    UserState(sysStack)    _UserState(EXEC_BASE_NAME, sysStack)
  2117.  
  2118. static __inline void
  2119. _UserState(void *SysBase, APTR sysStack)
  2120. {
  2121. struct Caos    MyCaos;
  2122.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2123. //    MyCaos.M68kStart    =    NULL;
  2124. //    MyCaos.M68kSize        =    0;
  2125.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2126. //    MyCaos.PPCStart        =    NULL;
  2127. //    MyCaos.PPCSize        =    0;
  2128.     MyCaos.d0        =(ULONG) sysStack;
  2129.     MyCaos.caos_Un.Offset    =    (-156);
  2130.     MyCaos.a6        =(ULONG) SysBase;    
  2131.     PPCCallOS(&MyCaos);
  2132. }
  2133.  
  2134. #define    Vacate(sigSem, bidMsg)    _Vacate(EXEC_BASE_NAME, sigSem, bidMsg)
  2135.  
  2136. static __inline void
  2137. _Vacate(void *SysBase, struct SignalSemaphore *sigSem, struct SemaphoreMessage *bidMsg)
  2138. {
  2139. struct Caos    MyCaos;
  2140.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2141. //    MyCaos.M68kStart    =    NULL;
  2142. //    MyCaos.M68kSize        =    0;
  2143.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2144. //    MyCaos.PPCStart        =    NULL;
  2145. //    MyCaos.PPCSize        =    0;
  2146.     MyCaos.a0        =(ULONG) sigSem;
  2147.     MyCaos.a1        =(ULONG) bidMsg;
  2148.     MyCaos.caos_Un.Offset    =    (-546);
  2149.     MyCaos.a6        =(ULONG) SysBase;    
  2150.     PPCCallOS(&MyCaos);
  2151. }
  2152.  
  2153. #define    Wait(signalSet)    _Wait(EXEC_BASE_NAME, signalSet)
  2154.  
  2155. static __inline ULONG
  2156. _Wait(void *SysBase, unsigned long signalSet)
  2157. {
  2158. struct Caos    MyCaos;
  2159.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2160. //    MyCaos.M68kStart    =    NULL;
  2161. //    MyCaos.M68kSize        =    0;
  2162.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2163. //    MyCaos.PPCStart        =    NULL;
  2164. //    MyCaos.PPCSize        =    0;
  2165.     MyCaos.d0        =(ULONG) signalSet;
  2166.     MyCaos.caos_Un.Offset    =    (-318);
  2167.     MyCaos.a6        =(ULONG) SysBase;    
  2168.     return((ULONG)PPCCallOS(&MyCaos));
  2169. }
  2170.  
  2171. #define    WaitIO(ioRequest)    _WaitIO(EXEC_BASE_NAME, ioRequest)
  2172.  
  2173. static __inline BYTE
  2174. _WaitIO(void *SysBase, struct IORequest *ioRequest)
  2175. {
  2176. struct Caos    MyCaos;
  2177.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2178. //    MyCaos.M68kStart    =    NULL;
  2179. //    MyCaos.M68kSize        =    0;
  2180.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2181. //    MyCaos.PPCStart        =    NULL;
  2182. //    MyCaos.PPCSize        =    0;
  2183.     MyCaos.a1        =(ULONG) ioRequest;
  2184.     MyCaos.caos_Un.Offset    =    (-474);
  2185.     MyCaos.a6        =(ULONG) SysBase;    
  2186.     return((BYTE)PPCCallOS(&MyCaos));
  2187. }
  2188.  
  2189. #define    WaitPort(port)    _WaitPort(EXEC_BASE_NAME, port)
  2190.  
  2191. static __inline struct Message *
  2192. _WaitPort(void *SysBase, struct MsgPort *port)
  2193. {
  2194. struct Caos    MyCaos;
  2195.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2196. //    MyCaos.M68kStart    =    NULL;
  2197. //    MyCaos.M68kSize        =    0;
  2198.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2199. //    MyCaos.PPCStart        =    NULL;
  2200. //    MyCaos.PPCSize        =    0;
  2201.     MyCaos.a0        =(ULONG) port;
  2202.     MyCaos.caos_Un.Offset    =    (-384);
  2203.     MyCaos.a6        =(ULONG) SysBase;    
  2204.     return((struct Message *)PPCCallOS(&MyCaos));
  2205. }
  2206.  
  2207. #endif /* SASC Pragmas */
  2208. #endif /* !_PPCPRAGMA_EXEC_H */
  2209.